// ==UserScript==
// @name         e学帮
// @namespace    http://tampermonkey.net/
// @version      v1.0.0
// @description  版本更新说明：（新增重要功能）在课程列表界面时，未学习课程自动开始学习（todo：逻辑待完善，已基本实现“自动学习”功能）；
// @author       vans
// @grant        none
// @match        https://u.sdhsg.com/kng/*
// @match        https://u.sdhsg.com/o2o/*
// ==/UserScript==
(function() {
    'use strict';
    console.log('e学帮脚本已启动 (v1.0.0) ',formattedTime());
    // 页面加载完成后初始化
    window.addEventListener('load', initPage);

    // 优化检查间隔为5秒，减少资源占用
    const CHECK_INTERVAL = 5000;
    //console.log("document.readyState:",document.readyState)
    setTimeout(() => {
        if(document.readyState === 'complete'){
        console.log("complete!!!  ",formattedTime())

        let checkInterval = setInterval(handleLearningActions, CHECK_INTERVAL);
        // 连续未检测到课程剩余时间的计数器
        window.consecutiveNoTimeCount = 0;
        // 提供清除定时器的方法，方便调试
        window.clearLearningInterval = () => {
            clearInterval(checkInterval);
            console.log('自动处理已停止');
        };
    }
    }, 2000);
    setTimeout(()=>{
        console.log("checkAndClickYesButton")
        checkAndClickYesButton();
    },12000);
})();

// 自动学习状态控制变量
let isAutoLearning = false;
// 存储定时器ID，用于停止操作
let timers = [];

// 检查当前页面是否为目标课程列表页
function isCourseListPage() {
    return window.location.hash.startsWith('#/list');
}

// 创建控制框元素
function createControlPanel() {
    // 检查是否已存在控制框，避免重复创建
    if (document.getElementById('courseAutoLearnPanel')) {
        return;
    }

    const panel = document.createElement('div');
    panel.id = 'courseAutoLearnPanel';
    panel.style.cssText = `
        position: fixed;
        top: 20px;
        left: 20px;
        background: white;
        border: 2px solid #333;
        border-radius: 8px;
        padding: 15px;
        z-index: 99999;
        box-shadow: 0 4px 12px rgba(0,0,0,0.15);
        font-family: Arial, sans-serif;
        min-width: 300px; /* 增加最小宽度 */
    `;

    // 标题
    const title = document.createElement('h3');
    title.textContent = '课程自动学习';
    title.style.margin = '0 0 10px 0';
    title.style.color = '#333';

    // 状态显示区域
    const statusContainer = document.createElement('div');
    statusContainer.id = 'learningStatus';
    statusContainer.style.cssText = `
        padding: 10px;
        margin: 0 0 15px 0;
        border-radius: 4px;
        background-color: #f5f5f5;
        min-height: 24px;
        font-size: 14px;
    `;
    statusContainer.textContent = '等待开始...';

    // 说明文字
    const desc = document.createElement('p');
    desc.textContent = '是否自动学习？（12秒后自动开始学习）';
    desc.style.margin = '0 0 15px 0';
    desc.style.fontSize = '14px';

    // 按钮容器
    const btnContainer = document.createElement('div');
    btnContainer.style.display = 'flex';
    btnContainer.style.gap = '10px';

    // 确认按钮
    const yesBtn = document.createElement('button');
    yesBtn.textContent = '是';
    yesBtn.className = 'yes-button';
    yesBtn.style.cssText = `
        padding: 6px 12px;
        background: #4CAF50;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 14px;
    `;
    yesBtn.addEventListener('click', () => {
        isAutoLearning = true;
        // 切换按钮显示状态
        yesBtn.style.display = 'none';
        noBtn.style.display = 'none';
        stopBtn.style.display = 'inline-block';
        updateStatus('开始自动学习...');
        startAutoLearning();
    });

    // 停止按钮
    const stopBtn = document.createElement('button');
    stopBtn.textContent = '停止';
    stopBtn.style.cssText = `
        padding: 6px 12px;
        background: #ff9800;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 14px;
        display: none;
    `;
    stopBtn.addEventListener('click', () => {
        stopAutoLearning();
        // 切换按钮显示状态
        stopBtn.style.display = 'none';
        yesBtn.style.display = 'inline-block';
        noBtn.style.display = 'inline-block';
        updateStatus('已停止自动学习');
    });

    // 取消按钮
    const noBtn = document.createElement('button');
    noBtn.textContent = '否';
    noBtn.style.cssText = `
        padding: 6px 12px;
        background: #f44336;
        color: white;
        border: none;
        border-radius: 4px;
        cursor: pointer;
        font-size: 14px;
    `;
    noBtn.addEventListener('click', () => {
        panel.style.display = 'none';
    });

    // 组装控制框
    btnContainer.appendChild(yesBtn);
    btnContainer.appendChild(stopBtn);
    btnContainer.appendChild(noBtn);
    panel.appendChild(title);
    panel.appendChild(statusContainer); // 添加状态显示区域
    panel.appendChild(desc);
    panel.appendChild(btnContainer);

    // 添加到页面
    document.body.appendChild(panel);
}
// 更新状态显示
function updateStatus(message) {
    const statusElement = document.getElementById('learningStatus');
    if (statusElement) {
        statusElement.textContent = message;
        console.log('[自动学习]', message);
        // 保存状态文本到localStorage
        //localStorage.setItem('autoLearnStatusText', text);
    }
}

// 清除所有定时器
function clearAllTimers() {
    timers.forEach(timerId => clearTimeout(timerId));
    timers = [];
}

// 注册定时器并保存ID
function setSafeTimeout(callback, delay) {
    const timerId = setTimeout(() => {
        // 只有在自动学习状态下才执行
        if (isAutoLearning) {
            callback();
        }
        // 从数组中移除已执行的定时器
        timers = timers.filter(id => id !== timerId);
    }, delay);
    timers.push(timerId);
    return timerId;
}
// 函数：检测并点击"是"按钮
function checkAndClickYesButton() {
    // 查找带有yes-button类的按钮
    const yesButton = document.querySelector('button.yes-button');

    if (yesButton) {
        // 检查按钮文本是否为"是"（可选验证）
        if (yesButton.textContent.trim() === '是') {
            console.log('找到带有yes-button类的"是"按钮，准备点击');
            yesButton.click();
            console.log('已点击带有yes-button类的按钮');
            return true; // 表示已点击
        } else {
            console.log('找到带有yes-button类的按钮，但文本不是"是"');
        }
    } else {
        console.log('未找到带有yes-button类的按钮');
    }
    return false; // 表示未点击
}

// 等待课程列表更新的辅助函数
function waitForCourseListUpdate() {
    setTimeout(()=>{
        window.location.reload(); // 刷新页面确保状态同

    },1000);

    return new Promise((resolve, reject) => {
        // 查找课程列表容器
        const courseListContainer = document.querySelector('ul.kng-list-new'); // 根据实际容器选择器修改
        console.log("courseListContainer:",courseListContainer);
        if (!courseListContainer) {
            reject('未找到课程列表容器');
            return;
        }

        // 最多等待10秒
        const timeout = setTimeout(() => {
            observer.disconnect();
            reject('等待课程列表更新超时');
        }, 10000);

        // 监听DOM变化
        const observer = new MutationObserver((mutations) => {
            for (const mutation of mutations) {
                // 检测课程项内部的"已学完"标签变化
                if (mutation.type === 'childList' && mutation.target.tagName === 'LI') {
                    const courseItem = mutation.target; // 单个课程项（li）
                    const completedTag = courseItem.querySelector('.kng-list-new__tag');

                    // 如果是目标课程（刚学完的课程），检测其是否出现"已学完"标签
                    if (targetCourseIndex !== -1) {
                        const currentIndex = Array.from(container.children).indexOf(courseItem);
                        if (currentIndex === targetCourseIndex && completedTag && completedTag.textContent.trim() === '已学完') {
                            clearTimeout(timeout);
                            observer.disconnect();
                            console.log(`课程 ${targetCourseIndex + 1} 状态已更新为"已学完"`);
                            resolve();
                            return;
                        }
                    } else {
                        // 非目标课程时，只要有任意课程项状态变化就认为列表已更新
                        clearTimeout(timeout);
                        observer.disconnect();
                        resolve();
                        return;
                    }
                }
            }
        });

        // 开始观察容器的子元素变化
        observer.observe(courseListContainer, {
            childList: true,
            subtree: true
        });
    });
}

// 检查课程并处理
function checkAndProcessCourses() {
    // 如果已停止，直接返回
    if (!isAutoLearning) return;

    // 查找所有课程项
    const courseItems = document.querySelectorAll('li.kng-list-new__item');

    if (courseItems.length === 0) {
        updateStatus('未找到课程项，可能页面尚未加载完成');
        console.log("未找到课程项，可能页面尚未加载完成");
        setSafeTimeout(checkAndProcessCourses, 2000);
        return;
    }

    // 查找第一个未学完的课程
    let unstudiedCourse = null;
    let courseIndex = -1;

    courseItems.forEach((item, index) => {
        if (!unstudiedCourse) {
            // 检查是否有"已学完"标签
            const tags = item.querySelectorAll('.kng-list-new__tag');
            let hasCompletedTag = false;

            tags.forEach(tag => {
                if (tag.textContent.trim() === '已学完') {
                    hasCompletedTag = true;
                }
            });

            if (!hasCompletedTag) {
                unstudiedCourse = item;
                courseIndex = index + 1; // 课程索引从1开始
            }
        }
    });

    if (unstudiedCourse && isAutoLearning) {
        // 获取课程名称（如果可能）
        const courseName = unstudiedCourse.textContent.trim().substring(0, 20) + '...';
        updateStatus(`正在学习第 ${courseIndex} 课: ${courseName}`);

        // 点击未学完的课程
        unstudiedCourse.click();

        // 监听页面变化，学习完成后返回列表页继续
        setSafeTimeout(() => {
            if (!isAutoLearning) return;

            // 这里可以根据实际学习页面的完成逻辑进行调整
            const backToList = () => {
                if (isAutoLearning) {
                    window.history.back();
                    updateStatus('课程学习完成，返回列表页');

                    // 等待目标课程状态更新为"已学完"
                    waitForCourseListUpdate().then(() => {
                        updateStatus('目标课程状态已更新，开始检查下一个课程');
                        checkAndProcessCourses();
                    }).catch((err) => {
                        console.warn(err + '，将使用备用方案检查课程');
                        // 超时后强制刷新列表（应对极端情况）
                        setTimeout(() => {
                            window.location.reload(); // 刷新页面确保状态同步
                            setTimeout(checkAndProcessCourses, 3000);
                        }, 3000);
                    });
                    // 如果没有刷新按钮，重新加载当前页面
                    //setSafeTimeout(() => window.location.reload(),1000);
                }
            };

            // 获取剩余时间文本并解析（支持时、分、秒）
            const timeElement = document.querySelector('.yxt-color-warning');
            console.log("timeElement:",timeElement);
            if (timeElement) {
                const timeText = timeElement.textContent.trim();

                // 分别匹配小时、分钟、秒
                const hourMatch = timeText.match(/(\d+)小时?/);    // 支持"1小时"或"1时"
                const minuteMatch = timeText.match(/(\d+)分钟?/);  // 支持"5分钟"或"5分"
                const secondMatch = timeText.match(/(\d+)秒/);

                // 解析为数字，默认0
                const hours = hourMatch ? parseInt(hourMatch[1], 10) : 0;
                const minutes = minuteMatch ? parseInt(minuteMatch[1], 10) : 0;
                const seconds = secondMatch ? parseInt(secondMatch[1], 10) : 0;

                // 转换为总毫秒数，额外加2秒确保完成
                const totalMilliseconds = (hours * 3600 + minutes * 60 + seconds + 6) * 1000;
                console.log("totalMilliseconds: ",totalMilliseconds)
                // 设置超时并更新状态
                setSafeTimeout(backToList, totalMilliseconds);

                // 格式化状态信息
                let timeInfo = [];
                if (hours > 0) timeInfo.push(`${hours}小时`);
                if (minutes > 0) timeInfo.push(`${minutes}分钟`);
                if (seconds > 0) timeInfo.push(`${seconds}秒`);
                updateStatus(`检测到课程剩余时长: ${timeInfo.join('')}，将在相应时间后返回`);
            } else {
                // 未找到时间元素时使用默认值
                //setSafeTimeout(backToList, 60000);
                // updateStatus('未检测到课程时长，使用默认1分钟');
            }
        }, 3000);
    } else if (isAutoLearning) {
        // 所有课程已学完，跳转到下一页
        const nextPageBtn = document.querySelector('button.btn-next:not([disabled])');
        if (nextPageBtn) {
            updateStatus('当前页课程已全部学完，正在跳转到下一页...');
            nextPageBtn.click();

            // 页面跳转后重新执行检查
            setSafeTimeout(checkAndProcessCourses, 5000);
        } else {
            updateStatus('所有页面课程已学习完成！');
            alert('所有课程已学习完成！');
            stopAutoLearning();
            // 恢复按钮显示状态
            const stopBtn = document.querySelector('#courseAutoLearnPanel button:nth-child(2)');
            const yesBtn = document.querySelector('#courseAutoLearnPanel button:nth-child(1)');
            const noBtn = document.querySelector('#courseAutoLearnPanel button:nth-child(3)');
            if (stopBtn && yesBtn && noBtn) {
                stopBtn.style.display = 'none';
                yesBtn.style.display = 'inline-block';
                noBtn.style.display = 'inline-block';
            }
        }
    }
}

// 开始自动学习流程
function startAutoLearning() {
    updateStatus('已开始自动学习模式');
    console.log('已开始自动学习模式');

    // 清除可能存在的定时器
    clearAllTimers();

    // 检查课程并处理
    checkAndProcessCourses();
}

// 停止自动学习
function stopAutoLearning() {
    isAutoLearning = false;
    clearAllTimers();
    updateStatus('已停止自动学习模式');
    console.log('已停止自动学习模式');
}

// 页面初始化处理
function initPage() {
    // 延迟检查，确保页面元素加载完成
    setTimeout(() => {
        if (isCourseListPage()) {
            createControlPanel();
        }

        // 监听hash变化，动态显示/隐藏控制框
        window.addEventListener('hashchange', () => {
            const existingPanel = document.getElementById('courseAutoLearnPanel');
            if (isCourseListPage()) {
                if (!existingPanel) {
                    createControlPanel();
                } else {
                    existingPanel.style.display = 'block';
                }
            } else if (existingPanel) {
                // 如果离开课程列表页，自动停止并隐藏控制框
                stopAutoLearning();
                existingPanel.style.display = 'none';
            }
        });
    }, 1000);
}
/**
* 当前时间
*/
function formattedTime(){

    // 创建一个 Date 对象
    var today = new Date();

    // 获取年、月、日、时、分、秒
    var year = today.getFullYear();
    var month = today.getMonth() + 1; // 月份是从 0 开始计数的，需要加1
    var day = today.getDate();
    var hours = today.getHours();
    var minutes = today.getMinutes();
    var seconds = today.getSeconds();

    // 格式化输出
    var currentTime = year + "-" +
        (month < 10 ? "0" : "") + month + "-" +
        (day < 10 ? "0" : "") + day + " " +
        (hours < 10 ? "0" : "") + hours + ":" +
        (minutes < 10 ? "0" : "") + minutes + ":" +
        (seconds < 10 ? "0" : "") + seconds;
    return currentTime;

}

/**
 * 处理所有学习相关的自动操作
 */
function handleLearningActions() {
    try {
        // 排除列表页面
        if (window.location.hash.includes('#/list')&&!window.location.hash.includes('/play')) {
            //console.log("当前页面为：",window.location,"直接跳过");
            return;
        }
        // 排除列表页面
        if (window.location.hash.includes('/project')&&!window.location.hash.includes('/playinfo')) {
            //console.log("当前页面为：",window.location,"直接跳过");
            return;
        }
        // 处理各种继续学习弹窗按钮
        handleContinueButtons();
        console.log("handleContinueButtons!!!  ",formattedTime());
        // 检测课程是否完成并处理下一个
        setTimeout(() => {
            try {
                // 检测课程是否完成，如已完成则点击下一个按钮
                checkAndHandleNextLesson();

                console.log("checkAndHandleNextLesson执行完成:",formattedTime());
            } catch (error) {
                console.error("checkAndHandleNextLesson函数执行出错:", error);
            }
        }, 20000);
    } catch (error) {
        console.error('处理学习操作时发生错误:', error);
    }
}

// 检测并播放视频的函数
function checkAndPlayVideo() {
    // 定义多种可能的视频元素选择器，适配不同页面结构
    const videoSelectors = [
        'video#videocontainer-vjs', // 页面视频元素ID
        'video.vjs-tech',           // 页面视频元素类名
        'video[jw-loaded="data"]'   // 基于属性的备选选择器
    ];

    let videoElement = null;
    // 依次尝试获取视频元素，找到第一个存在的
    for (const selector of videoSelectors) {
        videoElement = document.querySelector(selector);
        if (videoElement) break;
    }

    if (videoElement) {
        // 检查视频当前状态
        if (videoElement.paused) {
            console.log('视频未播放，尝试自动播放...');

            // 尝试播放视频
            videoElement.play()
                .then(() => {
                    console.log('视频已成功播放');
                })
                .catch(error => {
                    console.error('自动播放失败:', error.message);
                    // 某些浏览器可能因自动播放政策阻止播放，可在此添加用户交互提示
                    alert('视频播放需要您的许可，请点击视频后手动播放');
                });
        } else {
            console.log('视频正在播放中');
        }
    } else {
        console.log('未找到视频元素');
    }
}

/**
 * 安全点击元素的辅助函数
 * @param {HTMLElement} element - 要点击的元素
 * @param {string} description - 元素描述，用于日志
 * @returns {boolean} 是否成功点击
 */
function safeClick(element, description) {
    // 确保元素存在
    if (!element) {
        console.log(`无法点击${description}，元素不存在`);
        return false;
    }

    // 确保元素是HTMLElement类型
    if (!(element instanceof HTMLElement)) {
        console.log(`无法点击${description}，不是有效的HTML元素`);
        return false;
    }

    // 检查元素是否可见
    const isVisible = !!(element.offsetWidth || element.offsetHeight || element.getClientRects().length);
    if (!isVisible) {
        console.log(`无法点击${description}，元素不可见`);
        return false;
    }

    // 尝试直接点击
    if (typeof element.click === 'function') {
        try {
            element.click();
            console.log(`已点击${description}`);
            return true;
        } catch (e) {
            console.log(`点击${description}时发生错误:`, e);
        }
    }

    // 尝试通过创建鼠标事件来点击
    try {
        const event = new MouseEvent('click', {
            view: window,
            bubbles: true,
            cancelable: true
        });
        const success = element.dispatchEvent(event);
        if (success) {
            console.log(`已通过事件触发方式点击${description}`);
            return true;
        } else {
            console.log(`事件触发方式点击${description}失败`);
        }
    } catch (e) {
        console.log(`触发${description}点击事件时发生错误:`, e);
    }

    return false;
}

/**
 * 处理各种继续学习按钮
 */
function handleContinueButtons() {
    // 定义所有需要处理的按钮配置
    const buttonConfigs = [
        {
            selector: ".mt16.yxtulcdsdk-flex-center button.yxtf-button--primary",
            text: "开始学习",
            description: "包含SVG图标的开始学习按钮",
            delay: 7000
        },
        {
            selector: ".mt16.yxtulcdsdk-flex-center button.yxtf-button--primary",
            text: "继续学习",
            description: "包含SVG图标的开始学习按钮",
            delay: 7000
        },
        {
            selector: ".yxtf-dialog__body .text-center.mt26.mb4 button.ulcdsdk-nextchapterbutton",
            text: "继续学习下一章节",
            description: "课程完成后继续学习下一章节",
            delay: 3000 // 延迟点击，确保完成动画展示后再操作
        },
        {
            selector: ".yxtf-dialog__body > div:last-child > button",
            text: "继续学习",
            description: "挂机验证后继续学习"
        },
        {
            selector: ".mt16 > button",
            text: "继续学习",
            description: "章节继续学习"
        },
        {
            selector: ".yxtf-dialog__body > div:last-child > button",
            text: "继续学习下一阶段",
            description: "当前章节完成，继续下一阶段"
        },
        {
            selector: ".yxtf-dialog__body:nth-child(2) > div:last-child > button",
            text: "继续学习下一阶段",
            description: "弹窗中的下一阶段按钮"
        },
        {
            selector: ".mt24> button",
            text: "继续学习",
            description: "文档继续学习"
        },
        {
            selector: ".mt16 yxtulcdsdk-flex-center> button",
            text: "继续学习",
            description: "文档继续学习"
        },
        
        {
             selector: ".yxtf-dialog__body .mt12.text-right button.yxtf-button--primary",
             text: "确定",
             description: "确认切换到培训的下一个任务",
             delay: 2000 // 稍作延迟，确保弹窗完全加载
         }
    ];

    // 遍历检查并处理每个按钮
    buttonConfigs.forEach(config => {
        try {
            const button = document.querySelector(config.selector);
            if (button && button.textContent.trim() === config.text) {
                // 如果有延迟设置，则延迟点击
                const clickAction = () => {
                    safeClick(button, config.description);
                    // 点击后短暂停止检查，避免重复点击
                    setTimeout(() => {}, 1000);
                };

                if (config.delay) {
                    setTimeout(clickAction, config.delay);
                } else {
                    clickAction();
                }
            }
        } catch (error) {
            console.error(`处理按钮配置时出错 (${config.description}):`, error);
        }
    });
}

/**
 * 检测课程是否完成，如已完成则点击下一个按钮
 */
function checkAndHandleNextLesson() {
    try {
        // 检测是否存在剩余时间提示元素
        const timeRemainingElement = document.querySelector(".yxtbiz-language-slot.ltr-text");
        const hasTimeRemaining = timeRemainingElement &&
                               timeRemainingElement.textContent.includes("还需") &&
              timeRemainingElement.textContent.includes("可完成本课程学习");
        console.log("---------")
        console.log(hasTimeRemaining)
        if(hasTimeRemaining){
            // 检测并播放视频的函数
            checkAndPlayVideo();
        }

        // 如果没有剩余时间提示，说明当前课程已完成 ()
        if (!hasTimeRemaining ) {
            console.log("未检测到课程剩余时间，尝试查找下一个按钮...");

            // 增加连续未检测到课程的计数
            window.consecutiveNoTimeCount++;
            console.log(`连续未检测到课程剩余时间计数: ${window.consecutiveNoTimeCount}`);

            // 检查是否达到9次连续未检测到，如果是则关闭页面
            if (window.consecutiveNoTimeCount >= 9 ) {
                console.log("已连续9次未检测到课程剩余时间，将关闭当前页面");
                window.history.back();
                updateStatus('课程学习完成，返回列表页');
                // 关键优化：等待页面更新后再检查，使用更长延迟或DOM监听
                waitForCourseListUpdate().then(() => {
                    checkAndProcessCourses();
                }).catch(() => {
                    // 监听失败时使用备用方案
                    setSafeTimeout(checkAndProcessCourses, 5000);
                });
                //window.opener = null;
                //window.open(' ','_self');
                //window.close();
                return;
            }

            // 先尝试查找常规的下一个按钮
            const nextButtons = document.querySelectorAll('button.yxtf-button');
            let found = false;
            for (const button of nextButtons) {
                // 检查按钮是否包含"下一个"文本
                if (button.textContent.trim().startsWith("下一个")) {

                    safeClick(button, "下一个按钮，进入下一课程");
                    found = true;
                    // 点击后短暂延迟，避免重复操作
                    setTimeout(() => {}, 2000);
                    return;
                }
            }

            // 如果未找到常规按钮，尝试查找特定的div模块
            if (!found && typeof document.querySelectorAll === 'function') {
                // 先找到所有符合条件的div元素
                const candidateDivs = document.querySelectorAll(
                    'div.yxtulcdsdk-flex-center.over-hidden.yxtulcdsdk-action-icon.yxtulcdsdk-flex-vertical'
                );

                // 遍历div元素，检查是否包含"下一个"文本
                let nextDiv = null;
                for (const div of candidateDivs) {
                    try {
                        const spanElement = div.querySelector('span.nowrap');
                        if (spanElement && spanElement.textContent &&
                            spanElement.textContent.trim() === "下一个") {
                            nextDiv = div;
                            break;
                        }
                    } catch (e) {
                        console.log("检查div元素时出错:", e);
                    }
                }

                if (nextDiv) {

                    console.log("找到包含'下一个'的div模块，尝试点击...");

                    // 分步骤尝试点击
                    // 1. 尝试直接点击div
                    if (safeClick(nextDiv, "包含SVG图标的下一个div模块")) {
                        setTimeout(() => {}, 2000);
                        return;
                    }

                    // 2. 尝试点击内部元素，按优先级排序
                    const selectors = [
                        'button',          // 按钮
                        'a',               // 链接
                        'span.nowrap',     // 文本区域
                        'svg',             // SVG图标
                        'div'              // 内部div
                    ];

                    for (const selector of selectors) {
                        try {
                            const element = nextDiv.querySelector(selector);
                            if (element) {
                                if (safeClick(element, `div内部的${selector}元素`)) {
                                    setTimeout(() => {}, 2000);
                                    return;
                                }
                            }
                        } catch (e) {
                            console.log(`尝试点击${selector}时出错:`, e);
                        }
                    }

                    console.log("所有点击尝试都已失败");
                } else {
                    console.log("未找到包含'下一个'的div模块");
                }
            }
        } else {
            // 有剩余时间，重置计数器
            window.consecutiveNoTimeCount = 0;
            // 输出当前剩余时间
            try {
                const timeText = timeRemainingElement.querySelector(".yxt-color-warning")?.textContent;
                if (timeText) {
                    console.log(`当前课程剩余时间: ${timeText}`);
                }
            } catch (e) {
                console.log("获取剩余时间时出错:", e);
            }
        }
    } catch (error) {
        console.error('检查并处理下一课时代码出错:', error);
    }
}
